home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / plisthel.i < prev    next >
Text File  |  1997-10-26  |  21KB  |  689 lines
  1. IMPLEMENTATION MODULE PListHelp;
  2.  
  3. (*==============================================================*
  4.  * Modul:               Modul zur Verwaltung der Abrufboxen     *
  5.  * Autor:               Dirk Steins                             *
  6.  * erstellt am:         16.10.1993                              *
  7.  * letzte Žnderung am:  16.10.1993                              *
  8.  * Version:             1.0                                     *
  9.  * Interne Version:     V#0001                                  *
  10.  *==============================================================*
  11.  
  12.  *----------------------------------------------------------------------------
  13.  * Datum    Vers. Autor  Žnderung (Arbeitsbericht)                            
  14.  *----------------------------------------------------------------------------
  15.  *----------------------------------------------------------------------------
  16.  *)
  17.  
  18. FROM SYSTEM  IMPORT ADDRESS, TSIZE, ADR, CADR, CAST;
  19. FROM Storage IMPORT ALLOCATE, DEALLOCATE;
  20. IMPORT Lists;
  21. IMPORT PathCtrl;
  22. IMPORT Strings;
  23. IMPORT GrafBase;
  24. IMPORT BinOps;
  25. IMPORT ShellMsg;
  26.  
  27. FROM Void         IMPORT v;
  28. FROM ListDl       IMPORT WinListDial, specialButHdler, dummyInLoop, inLoopProc,
  29.                          BuildLdHandler, ldHandler, ldElems, ldElemSet, dummyCheckExit;
  30. IMPORT CatTypes;
  31. IMPORT ListMan;
  32. IMPORT CatGlobal;
  33. IMPORT ConfVars;
  34. IMPORT Varnames;
  35. IMPORT MTE;
  36. IMPORT EditFuncs;
  37. IMPORT CatFiles;
  38. IMPORT AssFuncs;
  39. IMPORT Fredrsc;
  40.  
  41. IMPORT MagicAES;
  42. IMPORT MagicDOS;
  43. IMPORT MagicStrings;
  44. IMPORT MagicTypes;
  45. IMPORT MagicSys;
  46.  
  47. IMPORT mtAppl;
  48. IMPORT mtDials;
  49. IMPORT mtAlerts;
  50. IMPORT mtUtils;
  51.  
  52.  
  53. VAR pathBox : ADDRESS;
  54.     globalLength : INTEGER;
  55.  
  56.  
  57. TYPE    pathEntry = RECORD
  58.                       entry:      PathCtrl.PathEntry;
  59.                       selected :  BOOLEAN;
  60.                     END;
  61.         pathPtr   = POINTER TO pathEntry;
  62.         
  63. (*------------------------------------------------------------------------*)
  64. PROCEDURE nextEntry ( l : ADDRESS) : ADDRESS;
  65.  VAR lp : POINTER TO Lists.List;
  66. BEGIN
  67.  lp := l;
  68.  RETURN Lists.NextEntry (lp^);
  69. END nextEntry;
  70.  
  71. PROCEDURE prevEntry ( l : ADDRESS) : ADDRESS;
  72.  VAR lp : POINTER TO Lists.List;
  73. BEGIN
  74.  lp := l;
  75.  RETURN Lists.PrevEntry (lp^)
  76. END prevEntry;
  77.  
  78. PROCEDURE countEntries ( l : ADDRESS; VAR ll: LONGINT; VAR ww: INTEGER);
  79.  VAR lp : POINTER TO Lists.List;
  80. BEGIN
  81.  lp := l;
  82.  ww := globalLength*mtAppl.CharWidth;
  83.  ll := VAL (LONGINT, Lists.NoOfEntries (lp^));
  84. END countEntries;
  85.  
  86. PROCEDURE resetList (l : ADDRESS);
  87.  VAR lp : POINTER TO Lists.List;
  88. BEGIN
  89.  lp := l;
  90.  Lists.ResetList (lp^);
  91. END resetList;
  92.  
  93. PROCEDURE isEnabled (adr : ADDRESS; env : ADDRESS) : BOOLEAN;
  94. BEGIN
  95.   RETURN TRUE
  96. END isEnabled;
  97.  
  98. (*------------------------------------------------------------------------*)
  99.  
  100. VAR pathList  : Lists.List;
  101.     clipEntry   : pathPtr;
  102.  
  103. PROCEDURE selGrEntry (entry, env : ADDRESS; line : INTEGER): BOOLEAN;
  104.   VAR gr : pathPtr;
  105.       str: CatTypes.String255;
  106. BEGIN
  107.   gr := entry;
  108.   IF gr = NIL THEN RETURN FALSE END;
  109.   gr^.selected := ~gr^.selected;
  110.   RETURN FALSE
  111. END selGrEntry;
  112.  
  113. PROCEDURE groupToStr (entry, env : ADDRESS; VAR str : ARRAY OF CHAR);
  114.   VAR gr : pathPtr;
  115. BEGIN
  116.   gr := entry;
  117.   IF gr = NIL THEN RETURN END;
  118.   MagicStrings.Assign (gr^.entry^,str);
  119.   globalLength := BinOps.HigherInt (globalLength, LENGTH (str)+2);
  120. END groupToStr;
  121.  
  122. (*$Z-*)  
  123. PROCEDURE findSel (e, i : ADDRESS): BOOLEAN;
  124.   VAR entry : pathPtr;
  125. BEGIN
  126.   entry := e;
  127.   RETURN entry^.selected;
  128. END findSel;
  129.  
  130. PROCEDURE findName (e, i : ADDRESS): BOOLEAN;
  131.   VAR entry : pathPtr;
  132.       str   : CatTypes.Str255Ptr;
  133. BEGIN
  134.   entry := e;
  135.   str := i;
  136.   RETURN AssFuncs.StrIequal (entry^.entry^, str^);
  137. END findName;
  138. (*$Z=*)
  139.  
  140. PROCEDURE cutEntry (obj: INTEGER; env, info : ADDRESS; VAR draw : BOOLEAN; VAR exit : BOOLEAN);
  141.   VAR r : GrafBase.Rectangle;
  142.       found : BOOLEAN;
  143.       listInfo : ListMan.LISTINFO;
  144. BEGIN
  145.   (* Selektierten Eintrag in der Liste finden und aus der Liste entfernen *)
  146.   Lists.ResetList (pathList);
  147.   Lists.ScanEntries (pathList, Lists.forward, findSel, NIL, found);
  148.   IF found THEN
  149.     IF clipEntry # NIL
  150.     THEN
  151.       (* Alten Eintrag l”schen *)
  152.       DEALLOCATE (clipEntry^.entry, 0);
  153.       DEALLOCATE (clipEntry, 0);
  154.     END;
  155.     clipEntry := Lists.CurrentEntry (pathList);
  156.     Lists.RemoveEntry (pathList, v.bool);
  157.     listInfo := ListMan.LISTINFO (info);
  158.     ListMan.ListScroll2Selection (listInfo, TRUE);
  159.     (* Nun das neue Icon darstellen *)
  160.     mtUtils.SetFlag (pathBox, Fredrsc.Pclfull, MagicAES.HIDETREE, FALSE);
  161.     mtUtils.SetFlag (pathBox, Fredrsc.Pclempty, MagicAES.HIDETREE, TRUE);
  162.     mtUtils.CalcArea (pathBox, Fredrsc.Pclfull, r);
  163.     mtDials.DialDraw (pathBox, 0, 8, r, TRUE);
  164.   END;
  165.   mtUtils.SetState (pathBox, obj, MagicAES.SELECTED, FALSE);
  166.   mtDials.DialDraw (pathBox, obj, 1, v.r, FALSE);
  167.   draw := found;
  168.   exit := FALSE;
  169. END cutEntry;
  170.  
  171. PROCEDURE pasteEntry (obj: INTEGER; env, info: ADDRESS; VAR draw : BOOLEAN; VAR exit : BOOLEAN);
  172.   VAR r : GrafBase.Rectangle;
  173.       r1, r2 : GrafBase.Rectangle;
  174.       x, y   : INTEGER;
  175.       kstate, 
  176.       buts  : BITSET;
  177.       found : BOOLEAN;
  178.       index : LONGINT;
  179.       adr   : pathPtr;
  180.       listInfo : ListMan.LISTINFO;
  181. BEGIN
  182.   exit := FALSE;
  183.   IF clipEntry = NIL
  184.   THEN
  185.     draw := FALSE;
  186.     RETURN
  187.   END;
  188.   mtUtils.ObjcArea (pathBox, Fredrsc.Pclfull, r1);
  189.   mtUtils.ObjcArea (pathBox, 0, r2);
  190.   MagicAES.GrafMkstate (x, y, buts, kstate);
  191.   IF (0 IN buts)
  192.   THEN
  193.     listInfo := ListMan.LISTINFO (info);
  194.     MagicAES.GrafDragbox (r1, r2, x, y);
  195.     MagicAES.GrafMkstate (x, y, buts, kstate);
  196.     index := ListMan.ListClick (listInfo, x, y, kstate, 0);
  197.     (* Pers”nliche bleiben immer vorne: *)
  198.     IF index = 0 THEN INC (index) END;
  199.     IF index > 0
  200.     THEN
  201.       adr := ListMan.ListFindEntry (listInfo, index);
  202.       IF adr = NIL
  203.       THEN
  204.         Lists.AppendEntry (pathList, clipEntry, v.bool);
  205.         index := LONG(Lists.NoOfEntries (pathList));
  206.       ELSE
  207.         IF index > 1 THEN adr := Lists.PrevEntry (pathList); END;
  208.         Lists.InsertEntry (pathList, clipEntry, v.bool);
  209.       END;
  210.       (* Jetzt mal schnell alle Eintr„ge deselektieren *)
  211.       Lists.ResetList (pathList);
  212.       adr := Lists.NextEntry (pathList);
  213.       WHILE adr # NIL DO
  214.         adr^.selected := FALSE;
  215.         adr := Lists.NextEntry (pathList);
  216.       END;
  217.       clipEntry^.selected := FALSE;
  218.       v.bool := selGrEntry (clipEntry, env, 0);
  219.       ListMan.ListScroll2Selection (listInfo, TRUE);
  220.       mtUtils.SetFlag (pathBox, Fredrsc.Pclfull, MagicAES.HIDETREE, TRUE);
  221.       mtUtils.SetFlag (pathBox, Fredrsc.Pclempty, MagicAES.HIDETREE, FALSE);
  222.       mtUtils.CalcArea (pathBox, Fredrsc.Pclempty, r);
  223.       mtDials.DialDraw (pathBox, 0, 8, r, TRUE);
  224.       clipEntry := NIL;
  225.       draw := TRUE;
  226.     ELSE
  227.       draw := FALSE;
  228.     END;
  229.   ELSE
  230.     draw := FALSE;
  231.   END;
  232. END pasteEntry;
  233.  
  234. PROCEDURE clipEmpty (obj: INTEGER; env, info : ADDRESS; VAR draw : BOOLEAN; VAR exit : BOOLEAN);
  235. CONST
  236.   clipInfo   = "[1][FRED:|Dieses Klemmbrett enth„lt den zuletzt|von Ihnen gel”schten Pfad. Momentan|";
  237.   clipInfo2  = "k”nnen Sie es nicht benutzen,|da es leer ist.][[Ok]";
  238. BEGIN
  239.   MTE.InfoAlert (clipInfo, clipInfo2, "");
  240.   draw := FALSE;
  241.   exit := FALSE;
  242. END clipEmpty;
  243.  
  244. PROCEDURE updateButton (entry, env : ADDRESS);
  245.   VAR oneSel : BOOLEAN;
  246.       gr     : pathPtr;
  247. BEGIN
  248.   Lists.ResetList (pathList);
  249.   Lists.ScanEntries (pathList, Lists.forward, findSel, NIL, oneSel);
  250.   IF oneSel
  251.   THEN
  252.     gr := Lists.CurrentEntry (pathList);
  253.   END;
  254.   IF   (oneSel  & mtUtils.InState (pathBox, Fredrsc.Pdelete, MagicAES.DISABLED))
  255.     OR (~oneSel & ~mtUtils.InState (pathBox, Fredrsc.Pdelete, MagicAES.DISABLED))
  256.   THEN
  257.     mtUtils.SetState (pathBox, Fredrsc.Pdelete, MagicAES.DISABLED, ~oneSel);
  258.     mtDials.DialDraw (pathBox, Fredrsc.Pdelete, 0, v.r, FALSE);
  259.     mtUtils.SetState (pathBox, Fredrsc.Pchange, MagicAES.DISABLED, ~oneSel);
  260.     mtDials.DialDraw (pathBox, Fredrsc.Pchange, 0, v.r, FALSE);
  261.   END;
  262. END updateButton;
  263.  
  264. PROCEDURE EnvSearch (VAR val : ARRAY OF CHAR; REF name: ARRAY OF CHAR;
  265.                      env : ADDRESS);
  266.                      
  267.   PROCEDURE search (str, name : ARRAY OF CHAR;
  268.                     VAR val : ARRAY OF CHAR) : BOOLEAN;
  269.     VAR i : INTEGER;
  270.   BEGIN
  271.     Strings.Append ('=',name,v.bool);
  272.     i := Strings.Pos (name, str, 0);
  273.     IF i < 0 THEN RETURN FALSE END;
  274.     Strings.Copy (str, i+INTEGER(Strings.Length(name)),
  275.                   INTEGER(Strings.Length (str)-Strings.Length(name))-i, val, v.bool);
  276.     RETURN TRUE
  277.   END search;
  278.   
  279.   VAR ch : POINTER TO CHAR;
  280.       lastCh : CHAR;
  281.       i      : INTEGER;
  282.       str    : ARRAY [0..2047] OF CHAR;
  283. BEGIN
  284.   ch := env;
  285.   lastCh := ch^;
  286.   i := 0;
  287.   (* Solange noch env da ist *)
  288.   WHILE (ch^ # 0C) OR (lastCh # 0C) DO
  289.     str[i] := ch^;
  290.     INC(i);
  291.     lastCh := ch^;
  292.     IF lastCh = 0C
  293.     THEN (* string complete, search *)
  294.       IF search(str, name, val) THEN RETURN
  295.       ELSE
  296.         str := "";
  297.         i := 0;
  298.       END;
  299.     END;
  300.     INC (ch);
  301.   END;
  302. END EnvSearch;
  303.  
  304. PROCEDURE getSystemPaths (obj: INTEGER; env, info: ADDRESS; VAR draw, exit: BOOLEAN);
  305.   VAR basePage    : MagicTypes.PtrPD;
  306.       systemPath  : ARRAY [0..2047] OF CHAR;
  307.       p, p1, p2   : INTEGER;
  308.       path        : CatTypes.String255;
  309.       new         : pathPtr;
  310.       ok          : BOOLEAN;
  311.  
  312. BEGIN
  313.   draw := FALSE;
  314.   (* suchen nach Environment-Variable PATH *)
  315.   basePage := MagicSys.Basepage();
  316.   systemPath[0] := '';
  317.   EnvSearch (systemPath, 'PATH', basePage^.pEnv);
  318.   IF systemPath[0] # ''
  319.   THEN
  320.     IF (systemPath[0] = ',')
  321.     OR (systemPath[0] = ';')
  322.     THEN
  323.       p := 1;
  324.     ELSE
  325.       p := 0;
  326.     END;
  327.     REPEAT
  328.       p1 := Strings.Pos (',', systemPath, p);
  329.       p2 := Strings.Pos (';', systemPath, p);
  330.       IF (p1 > 0) OR (p2 > 0)
  331.       THEN
  332.         IF (p1 > 0) & ((p1 < p2) OR (p2 < 0))
  333.         THEN
  334.           (* Komma als Trenner gefunden *)
  335.           Strings.Copy (systemPath, p, p1-p, path, v.bool);
  336.           p := p1+1;
  337.         ELSIF (p2 > 0) & ((p2 < p1) OR (p1 < 0))
  338.         THEN
  339.           (* Semikolon als Trenner gefunden *)
  340.           Strings.Copy (systemPath, p, p2-p, path, v.bool);
  341.           p := p2+1;
  342.         END;
  343.         (* Erstmal nachsehen, ob der Pfad eh schon drin ist *)
  344.         Lists.ResetList (pathList);
  345.         Lists.ScanEntries (pathList, Lists.forward, findName, ADR(path), ok);
  346.         IF ~ok
  347.         THEN
  348.           (* Jetzt neuen Eintrag fr die Liste erzeugen *)
  349.           NEW (new);
  350.           IF new # NIL
  351.           THEN
  352.             ALLOCATE (new^.entry, LENGTH (path)+2);
  353.             IF new^.entry # NIL
  354.             THEN
  355.               MagicStrings.Assign (path, new^.entry^);
  356.               globalLength := BinOps.HigherInt (globalLength, LENGTH (path)+2);
  357.               new^.selected := FALSE;
  358.               (* Neuen Eintrag anlegen *)
  359.               Lists.AppendEntry (pathList, new, v.bool);
  360.               draw := TRUE;
  361.             ELSE
  362.               DISPOSE (new);
  363.             END;
  364.           END;
  365.         END;
  366.       ELSE 
  367.         p := -1;
  368.       END;
  369.     UNTIL p < 0;
  370.   END;
  371.   exit := FALSE;
  372.   mtUtils.ExclState (pathBox, obj, MagicAES.SELECTED);
  373.   mtDials.DialDraw (pathBox, obj, 1, v.r, FALSE);
  374. END getSystemPaths;
  375.  
  376. PROCEDURE changeGroup (obj: INTEGER; env, info: ADDRESS; VAR draw, exit: BOOLEAN);
  377. CONST cTitel    = 'Pfad ausw„hlen';
  378.  
  379.   VAR wegen: ADDRESS;
  380.       cPath : CatTypes.String255;
  381.       name  : CatTypes.String127;
  382.       oneSel: BOOLEAN;
  383.       but   : INTEGER;
  384.       ok    : BOOLEAN;
  385.       gr    : pathPtr;
  386.       new   : pathPtr;
  387.       path  : ADDRESS;
  388. BEGIN
  389.   draw := FALSE;
  390.   Lists.ResetList (pathList);
  391.   Lists.ScanEntries (pathList, Lists.forward, findSel, NIL, oneSel);
  392.   IF oneSel 
  393.   THEN
  394.     gr := Lists.CurrentEntry (pathList);
  395.     MagicStrings.Assign (gr^.entry^, cPath);
  396.   ELSE
  397.     CatFiles.GetPath (cPath);
  398.   END;
  399.   MagicStrings.Assign ('', name);
  400.   IF CatGlobal.FselGet(cPath, name, '*.*', cTitel, TRUE)
  401.   THEN
  402.     (* Mal nachsehen, ob der Pfad schon da ist *)
  403.     Lists.ResetList (pathList);
  404.     Lists.ScanEntries (pathList, Lists.forward, findName, ADR(cPath), ok);
  405.     IF ok
  406.     THEN
  407.       IF ((obj = Fredrsc.Pchange) & (gr # Lists.CurrentEntry (pathList)))
  408.       OR (obj = Fredrsc.Pnew)
  409.       THEN
  410.         MTE.info ('[3][FRED:|Der Pfad ist schon|in der Pfadliste!][[Abbruch]');
  411.       END;
  412.     END;
  413.     IF ~ok (* nicht vorhanden in Liste *)
  414.     THEN
  415.       (* Neuen Eintrag erzeugen *)
  416.       ALLOCATE (path, LENGTH (cPath) + 2);
  417.       IF path # NIL
  418.       THEN 
  419.         NEW (new);
  420.         IF new # NIL
  421.         THEN
  422.           new^.entry := path;
  423.           MagicStrings.Assign (cPath, new^.entry^);
  424.           globalLength := BinOps.HigherInt (globalLength, LENGTH (cPath)+2);
  425.           new^.selected := FALSE;
  426.           (* Jetzt nach Objekt unterscheiden *)
  427.           IF obj = Fredrsc.Pnew
  428.           THEN
  429.             (* Neuen Eintrag anlegen *)
  430.             Lists.AppendEntry (pathList, new, v.bool);
  431.           ELSE
  432.             (* vorhandenen Eintrag suchen und ersetzen *)
  433.             Lists.ResetList (pathList);
  434.             Lists.ScanEntries (pathList, Lists.forward, findSel, NIL, oneSel);
  435.             gr := Lists.CurrentEntry (pathList);
  436.             Lists.RemoveEntry (pathList, v.bool);
  437.             DEALLOCATE (gr^.entry, 0);
  438.             DEALLOCATE (gr, 0);
  439.             Lists.InsertEntry (pathList, new, v.bool);
  440.           END;
  441.           draw := TRUE;
  442.         ELSE
  443.           DEALLOCATE (path, 0);
  444.           EditFuncs.OutOfMem();
  445.         END;
  446.       ELSE
  447.         EditFuncs.OutOfMem();
  448.       END;
  449.     END;  (* IF nicht in Liste *)
  450.   END; (* IF FselGet *)
  451.   mtUtils.ExclState (pathBox, obj, MagicAES.SELECTED);
  452.   mtDials.DialDraw (pathBox, obj, 1, v.r, FALSE);
  453.   exit := FALSE;
  454. END changeGroup;
  455.  
  456. (* List-Zwischen-Prozeduren *)
  457. PROCEDURE groupIsSelected (entry, env : ADDRESS) : BOOLEAN;
  458.   VAR ent : pathPtr;
  459. BEGIN
  460.   ent := entry;
  461.   RETURN ent^.selected;
  462. END groupIsSelected;
  463.  
  464. VAR  tr     : mtUtils.tObjcTree;
  465.  
  466. PROCEDURE drawGroupEntry (entry, env : ADDRESS; x, y : INTEGER;
  467.                           offset : INTEGER; clip   : GrafBase.Rectangle);
  468.  
  469.   CONST spaceString = "          ";
  470.      VAR e   : pathPtr;
  471.          str : CatTypes.String255;
  472.   BEGIN
  473.     e := entry;
  474.     tr^[0].obX := x;
  475.     tr^[0].obY := y;
  476.     tr^[0].obSpec.TedPtr^.teTxtlen := globalLength;
  477.     tr^[0].obWidth := globalLength*mtAppl.CharWidth;
  478.     IF e # NIL
  479.     THEN
  480.       (* Jetzt hier den String fr den Gruppennamen zusammenbauen *)
  481.       groupToStr (e, env,  str);
  482.       mtUtils.SetObjcStringAdr (tr, 0, ADR(str));
  483.       mtUtils.SetState (tr, 0, MagicAES.SELECTED, groupIsSelected (entry, env));
  484.       mtUtils.SetState (tr, 0, MagicAES.DISABLED, ~isEnabled (entry, env));
  485.     ELSE
  486.       mtUtils.SetObjcStringAdr (tr, 0, CADR(spaceString));
  487.       mtUtils.SetState (tr, 0, MagicAES.SELECTED, FALSE);
  488.       mtUtils.SetState (tr, 0, MagicAES.DISABLED, FALSE);
  489.     END;
  490.     MagicAES.ObjcDraw (tr, 0, 8, clip);
  491.   END drawGroupEntry;
  492.  
  493. PROCEDURE killPathList();
  494.   VAR entry : pathPtr;
  495. BEGIN
  496.   Lists.ResetList (pathList);
  497.   entry := Lists.NextEntry (pathList);
  498.   WHILE entry # NIL DO
  499.     Lists.RemoveEntry (pathList, v.bool);
  500.     DEALLOCATE (entry^.entry, 0);
  501.     DEALLOCATE (entry, 0);
  502.     entry := Lists.NextEntry (pathList);
  503.   END;
  504.   Lists.DeleteList (pathList, v.bool);
  505. END killPathList;
  506.  
  507. PROCEDURE setAndGetPathValues (tree: ADDRESS; private: ADDRESS; set: BOOLEAN; exitBut: INTEGER);
  508.   VAR iPtr : POINTER TO INTEGER;
  509. BEGIN
  510.   IF set
  511.   THEN
  512.   ELSE
  513.     iPtr := private;
  514.     iPtr^ := exitBut;
  515.   END;
  516. END setAndGetPathValues;
  517.  
  518. (* Pfadeinstellungen vornehmen *)
  519. PROCEDURE SelectPaths (tree: ADDRESS);
  520.   
  521.   VAR exit : INTEGER;
  522.         
  523.   VAR specials : ARRAY [0..5] OF specialButHdler;
  524.       gr,
  525.       group    : pathPtr;
  526.       found    : BOOLEAN;
  527.       GroupOk  : BOOLEAN;
  528.       maxLength: INTEGER;
  529.       r        : GrafBase.Rectangle;
  530.       ilProc   : inLoopProc;
  531.       whichList: BOOLEAN;
  532.       entry    : CatTypes.Str255Ptr;
  533.       succ     : BOOLEAN;
  534.       pathHandler: ldHandler;
  535.  
  536. BEGIN
  537.   pathBox := tree;
  538.   mtUtils.SetFlag (pathBox, Fredrsc.Pclfull, MagicAES.HIDETREE, TRUE);
  539.   mtUtils.SetFlag (pathBox, Fredrsc.Pclempty, MagicAES.HIDETREE, FALSE);
  540.   
  541.   found := FALSE;
  542.   (* specials bestimmen *)
  543.   specials[0].objc := Fredrsc.Pdelete;
  544.   specials[0].proc := cutEntry;
  545.   specials[1].objc := Fredrsc.Pclfull;
  546.   specials[1].proc := pasteEntry;
  547.   specials[2].objc := Fredrsc.Pclempty;
  548.   specials[2].proc := clipEmpty;
  549.   specials[3].objc := Fredrsc.Pnew;
  550.   specials[3].proc := changeGroup;
  551.   specials[4].objc := Fredrsc.Pchange;
  552.   specials[4].proc := changeGroup;
  553.   specials[5].objc := Fredrsc.Ppath;
  554.   specials[5].proc := getSystemPaths;
  555.   IF clipEntry # NIL
  556.   THEN
  557.     (* Alten Eintrag l”schen *)
  558.     DEALLOCATE (clipEntry^.entry, 0);
  559.     DEALLOCATE (clipEntry, 0);
  560.   END;
  561.   clipEntry := NIL;
  562.   ilProc := updateButton;
  563.  
  564.   (* Jetzt die Liste aufbauen *)
  565.   Lists.ResetList (ShellMsg.SrcPaths);
  566.   entry := Lists.NextEntry (ShellMsg.SrcPaths);
  567.   Lists.CreateList (pathList, succ);
  568.   IF succ
  569.   THEN
  570.     mtDials.DisposeDial (pathBox); 
  571.     EditFuncs.OutOfMem();
  572.     RETURN 
  573.   END;
  574.   succ := TRUE;
  575.   WHILE (entry # NIL) & succ DO
  576.     NEW (group);
  577.     IF group = NIL
  578.     THEN
  579.       succ := FALSE;
  580.     ELSE
  581.       ALLOCATE (group^.entry, LENGTH (entry^)+2);
  582.       IF group^.entry = NIL
  583.       THEN
  584.         succ := FALSE;
  585.       ELSE
  586.         MagicStrings.Assign (entry^, group^.entry^);
  587.         group^.selected := FALSE;
  588.         Lists.AppendEntry (pathList, group, v.bool);
  589.         succ := ~v.bool;
  590.       END;
  591.     END;
  592.     entry := Lists.NextEntry (ShellMsg.SrcPaths);
  593.   END;
  594.   
  595.   IF ~succ THEN 
  596.     killPathList();
  597.     mtDials.DisposeDial (pathBox); 
  598.     EditFuncs.OutOfMem();
  599.     RETURN 
  600.   END;
  601.  
  602.   (* Maximale Breite eines Listeneintrages herausfinden *)
  603.   maxLength := 0;
  604.   Lists.ResetList (pathList);
  605.   group := Lists.NextEntry (pathList);
  606.   WHILE group # NIL DO 
  607.     IF INTEGER(LENGTH (group^.entry^)) > maxLength 
  608.     THEN
  609.       maxLength := LENGTH (group^.entry^);
  610.     END;
  611.     group := Lists.NextEntry (pathList);
  612.   END;
  613.   INC (maxLength);   (* damit es besser aussieht :-) *)
  614.   
  615.   (* Jetzt das Object zusammenbauen *)
  616.   mtUtils.CalcArea (pathBox, Fredrsc.Pathbox, r);
  617.   maxLength := BinOps.HigherInt (maxLength, r.w DIV mtAppl.CharWidth);
  618.  
  619.   globalLength := maxLength;
  620.   
  621.   (* Objectadresse holen *)
  622.   tr := MagicAES.RsrcGaddr (MagicAES.RTREE, Fredrsc.Listtxt);
  623.   
  624.   (* Handler bauen *)
  625.   BuildLdHandler (ADR(pathList), resetList, nextEntry, prevEntry,
  626.                   countEntries, isEnabled, selGrEntry,
  627.                   groupToStr, groupIsSelected, drawGroupEntry,
  628.                   0, mtAppl.CharHeight, 
  629.                   8, maxLength*mtAppl.CharWidth,
  630.                   pathHandler);
  631.   
  632.   (* ListDialog durchfhren *)
  633.   IF WinListDial (pathBox, ldElemSet{ldSelect, ldArrows, ldDoubleExit, ldModal},
  634.                       pathHandler,
  635.                       Fredrsc.Pathbox,
  636.                       Fredrsc.Pathback,
  637.                       Fredrsc.Pok,
  638.                       Fredrsc.Pcancel,
  639.                       ADR(exit), Fredrsc.Pok,
  640.                       -1,
  641.                       ilProc,
  642.                       specials,
  643.                       6,
  644.                       dummyCheckExit,
  645.                       setAndGetPathValues,
  646.                       setAndGetPathValues,
  647.                       group)
  648.   THEN
  649.     IF exit = Fredrsc.Pok THEN
  650.       (* Ver„nderte Pfadliste speichern *)
  651.       (* Erstmal die alte l”schen *)
  652.       Lists.ResetList (ShellMsg.SrcPaths);
  653.       entry := Lists.NextEntry (ShellMsg.SrcPaths);
  654.       WHILE entry # NIL DO
  655.         Lists.RemoveEntry (ShellMsg.SrcPaths, v.bool);
  656.         (* DEALLOCATE (entry, 0); *)
  657.         entry := Lists.NextEntry (ShellMsg.SrcPaths);
  658.       END;
  659.       Lists.ResetList (ShellMsg.SrcPaths);
  660.       Lists.ResetList (pathList);
  661.       group := Lists.NextEntry (pathList);
  662.       succ := TRUE;
  663.       WHILE (group # NIL) & succ DO 
  664.         entry := NIL;
  665.         ALLOCATE (entry, LENGTH (group^.entry^)+2);
  666.         IF entry = NIL
  667.         THEN
  668.           succ := FALSE;
  669.         ELSE
  670.           MagicStrings.Assign (group^.entry^, entry^);
  671.           Lists.AppendEntry (ShellMsg.SrcPaths, entry, v.bool);
  672.           succ := ~v.bool;
  673.         END;
  674.         group := Lists.NextEntry (pathList);
  675.       END;
  676.       IF ~succ THEN 
  677.         EditFuncs.OutOfMem();
  678.       END;
  679.     END;
  680.   END;
  681.                       
  682.   (* Interne Pfadliste wieder freigeben *)
  683.   killPathList();
  684. END SelectPaths;
  685.  
  686. BEGIN
  687.   clipEntry := NIL;
  688. END PListHelp.
  689.